CM3D2 Converter.misc_DATA_PT_modifiers

  1# 「プロパティ」エリア → 「モディファイア」タブ
  2import os
  3import re
  4import struct
  5import math
  6import unicodedata
  7import time
  8import bpy
  9import bmesh
 10import mathutils
 11from . import common
 12from . import compat
 13from .translations.pgettext_functions import *
 14
 15
 16# メニュー等に項目追加
 17def menu_func(self, context):
 18    ob = context.active_object
 19    if ob:
 20        if ob.type == 'MESH':
 21            me = ob.data
 22            if len(ob.modifiers):
 23                self.layout.operator('object.forced_modifier_apply', icon_value=common.kiss_icon())
 24
 25
 26@compat.BlRegister()
 27class CNV_UL_modifier_selector(common.CNV_UL_generic_selector):
 28    bl_label       = 'CNV_UL_modifier_selector'
 29    bl_options     = {'DEFAULT_CLOSED'}
 30    bl_region_type = 'WINDOW'
 31    bl_space_type  = 'PROPERTIES'
 32
 33    # Constants (flags)
 34    # Be careful not to shadow FILTER_ITEM!
 35    #bitflag_forced_true  = 1 << 0
 36    #bitflag_forced_false = 1 << 1
 37    #force_values = False
 38    #did_force_values = False
 39
 40    force_values = bpy.props.BoolProperty(
 41        name="force_values",
 42        default=False,
 43        options=set(),
 44    )
 45
 46    did_force_values = bpy.props.BoolProperty(
 47        name="force_values",
 48        default=False,
 49        options=set(),
 50    )
 51
 52    # This allows us to have mutually exclusive options, which are also all disable-able!
 53    def _gen_force_values(self, context):
 54        setattr(self, "force_values", True)
 55        setattr(self, "did_force_values", False)
 56        print("SET TRUE force_values =", self.force_values)
 57    
 58    def _gen_visible_update(name1, name2):
 59        def _u(self, context):
 60            self._gen_force_values(context)
 61            if (getattr(self, name1)):
 62                setattr(self, name2, False)
 63        return _u
 64    use_filter_viewport_visible = bpy.props.BoolProperty(
 65        name="Viewport",
 66        default=False,
 67        options=set(),
 68        description="Only enable modifiers visible in viewport",
 69        update=_gen_visible_update("use_filter_viewport_visible", "use_filter_renderer_visible"),
 70    )
 71    use_filter_renderer_visible = bpy.props.BoolProperty(
 72        name="Renderer",
 73        default=False,
 74        options=set(),
 75        description="Only enable modifiers visible in renderer",
 76        update=_gen_visible_update("use_filter_renderer_visible", "use_filter_viewport_visible"),
 77    )
 78    use_filter_reversed_visible = bpy.props.BoolProperty(
 79        name="Reverse Visible Filter",
 80        default=False,
 81        options=set(),
 82        description="Reverse the selected visible-in filter",
 83        update=_gen_force_values
 84    )
 85
 86
 87    use_filter_name_reverse = bpy.props.BoolProperty(
 88        name="Reverse Name",
 89        default=False,
 90        options=set(),
 91        description="Reverse name filtering",
 92    )
 93
 94    def _gen_order_update(name1, name2):
 95        def _u(self, ctxt):
 96            if (getattr(self, name1)):
 97                setattr(self, name2, False)
 98        return _u
 99    use_order_name = bpy.props.BoolProperty(
100        name="Name", default=False, options=set(),
101        description="Sort groups by their name (case-insensitive)",
102        update=_gen_order_update("use_order_name", "use_order_importance"),
103    )
104    use_filter_orderby_invert = bpy.props.BoolProperty(
105        name="Order by Invert",
106        default=False,
107        options=set(),
108        description="Invert the sort by order"
109    )
110
111
112    def draw_filter(self, context, layout):
113        row = layout.row()
114        row.label(text="Visible in:")
115        subrow = row.row(align=True)
116        subrow.prop(self, "use_filter_viewport_visible", toggle=True)
117        subrow.prop(self, "use_filter_renderer_visible", toggle=True)
118        icon = 'ZOOM_OUT' if self.use_filter_reversed_visible else 'ZOOM_IN'
119        icon = compat.icon(icon)
120        subrow.prop(self, "use_filter_reversed_visible", text="", icon=icon)
121
122        super(CNV_UL_modifier_selector, self).draw_filter(context, layout)
123
124    def filter_items(self, context, data, propname):
125        flt_flags, flt_neworder = super(CNV_UL_modifier_selector, self).filter_items(context, data, propname)
126        items = getattr(data, propname)
127
128        if getattr(self, 'did_force_values'):
129            setattr(self,'force_values', False)
130        setattr(self, 'did_force_values', getattr(self, 'force_values'))
131
132        print("CHECK force_values = ", getattr(self, 'force_values'))
133
134        if self.use_filter_viewport_visible or self.use_filter_renderer_visible or getattr(self, 'force_values'):
135
136            if not self.use_filter_reversed_visible:
137                in_flag  = self.bitflag_forced_true 
138                out_flag = ~(self.bitflag_forced_false | self.bitflag_soft_filter)
139            else:
140                in_flag  = self.bitflag_forced_false | self.bitflag_soft_filter
141                out_flag = ~self.bitflag_forced_true
142
143            for index, item in enumerate(items):
144                if getattr(self, 'force_values'):
145                    flt_flags[index] |= self.bitflag_forced_value
146
147                if self.use_filter_viewport_visible and item.filter0:
148                    flt_flags[index] |= in_flag
149                    flt_flags[index] &= out_flag
150                elif self.use_filter_renderer_visible and item.filter1:
151                    flt_flags[index] |= in_flag
152                    flt_flags[index] &= out_flag
153                elif not self.use_filter_viewport_visible and not self.use_filter_renderer_visible:
154                    pass
155                else:
156                    flt_flags[index] |= ~out_flag
157                    flt_flags[index] &= ~in_flag
158
159        return flt_flags, flt_neworder
160
161
162@compat.BlRegister()
163class CNV_OT_forced_modifier_apply(bpy.types.Operator):
164    bl_idname = 'object.forced_modifier_apply'
165    bl_label = "モディファイア強制適用"
166    bl_description = "シェイプキーのあるメッシュのモディファイアでも強制的に適用します"
167    bl_options = {'REGISTER', 'UNDO'}
168    
169    is_preserve_shape_key_values = bpy.props.BoolProperty(name="Preserve Shape Key Values", default=True , description="Ensure shape key values are not changed")
170
171    #is_applies = bpy.props.BoolVectorProperty(name="適用するモディファイア", size=32, options={'SKIP_SAVE'})
172    is_applies = bpy.props.CollectionProperty(type=common.CNV_SelectorItem)
173    active_modifier = bpy.props.IntProperty(name="Active Modifier")
174
175    apply_viewport_visible = bpy.props.BoolProperty(name="Apply Viewport-Visible Modifiers", default=False)
176    apply_renderer_visible = bpy.props.BoolProperty(name="Apply Renderer-Visible Modifiers", default=False)
177
178    initial_progress = bpy.props.FloatProperty(name="Progress", default=-1, options={'HIDDEN', 'SKIP_SAVE'})
179    
180    
181    @classmethod
182    def poll(cls, context):
183        ob = context.active_object
184        return len(ob.modifiers)
185
186    def invoke(self, context, event):
187        ob = context.active_object
188        if len(ob.modifiers) == 0:
189            return {'CANCELLED'}
190
191        for index, mod in enumerate(ob.modifiers):
192            #if index >= 32: # luvoid : can only apply 32 modifiers at once.
193            #    self.report(type={'WARNING'}, message="Can only apply the first 32 modifiers at once.")
194            #    break
195            icon = 'MOD_%s' % mod.type.replace('DECIMATE','DECIM').replace('SOFT_BODY','SOFT').replace('PARTICLE_SYSTEM','PARTICLES').replace('_SPLIT','SPLIT').replace('_PROJECT','PROJECT').replace('_DEFORM','DEFORM').replace('_SIMULATION','SIM').replace('_EDIT','').replace('_MIX','').replace('_PROXIMITY','').replace('_PAINT','PAINT')
196            icon = compat.icon(icon)
197            
198            new_prop = None
199            if index < len(self.is_applies):
200                new_prop = self.is_applies[index]
201            else:
202                new_prop = self.is_applies.add()
203            
204            if new_prop.name == mod.name and new_prop.icon == icon:
205                # It's probably the same one, ignore it
206                pass
207            else:
208                new_prop.name      = mod.name
209                new_prop.index     = index
210                new_prop.value     = mod.show_viewport
211                new_prop.preferred = new_prop.value
212                new_prop.icon      = icon
213                new_prop.filter0   = mod.show_viewport
214                new_prop.filter1   = mod.show_render
215
216        while len(self.is_applies) > len(ob.modifiers):
217            self.is_applies.remove(len(self.is_applies)-1)
218
219        return context.window_manager.invoke_props_dialog(self)
220
221    def draw(self, context):
222        prefs = common.preferences()
223        if compat.IS_LEGACY:
224            self.layout.prop(prefs, 'custom_normal_blend'         , icon=compat.icon('SNAP_NORMAL'  ), slider=True)
225        self.layout.prop(self , 'is_preserve_shape_key_values', icon=compat.icon('SHAPEKEY_DATA'), slider=True)
226        self.layout.label(text="適用するモディファイア")
227        ob = context.active_object
228
229        #for index, mod in enumerate(ob.modifiers):
230        #    if index >= 32: # luvoid : can only apply 32 modifiers at once.
231        #        break
232        #    icon = 'MOD_%s' % mod.type.replace('DECIMATE','DECIM').replace('SOFT_BODY','SOFT').replace('PARTICLE_SYSTEM','PARTICLES').replace('_SPLIT','SPLIT').replace('_PROJECT','PROJECT').replace('_DEFORM','DEFORM').replace('_SIMULATION','SIM').replace('_EDIT','').replace('_MIX','').replace('_PROXIMITY','').replace('_PAINT','PAINT')
233        #    try:
234        #        self.layout.prop(self, 'is_applies', text=mod.name, index=index, icon=icon)
235        #    except:
236        #        self.layout.prop(self, 'is_applies', text=mod.name, index=index, icon='MODIFIER')
237        
238        self.layout.template_list("CNV_UL_modifier_selector", "", self, "is_applies", self, "active_modifier")
239        self.layout.label(text="Show filters", icon='FILE_PARENT')
240
241    def execute(self, context):
242        ob = context.object
243
244        did_start_progress = False
245        if self.initial_progress == -1:
246            progress_start = 0
247            context.window_manager.progress_begin(0, 1)
248            did_start_progress = True
249        else:
250            progress_start = self.initial_progress
251
252        if self.apply_viewport_visible or self.apply_renderer_visible:
253            for index, mod in enumerate(ob.modifiers):
254                new_prop = None
255                if index < len(self.is_applies):
256                    new_prop = self.is_applies[index]
257                else:
258                    new_prop = self.is_applies.add()
259                
260                new_prop.name      = mod.name
261                new_prop.index     = index
262                new_prop.value     = (self.apply_viewport_visible and mod.show_viewport) or (self.apply_renderer_visible and mod.show_render)
263
264        # 対象が一つも無い場合はキャンセル扱いとする
265        is_any = False
266        for item in self.is_applies:
267            if item.value:
268                is_any = True
269                break
270        if not is_any:
271            self.report(type={'INFO'}, message="適用対象のモディファイアがないため、キャンセルします")
272            context.window_manager.progress_update(progress_start + 1)
273            if did_start_progress:
274                context.window_manager.progress_end()
275            return {'CANCELLED'}
276
277        custom_normal_blend = common.preferences().custom_normal_blend
278        bpy.ops.object.mode_set(mode='OBJECT')
279
280        me = ob.data
281        is_shaped = bool(me.shape_keys)
282
283        pre_selected_objects = context.selected_objects[:]
284        pre_mode = ob.mode
285
286        arm_ob = None
287        if compat.IS_LEGACY:
288            for mod in ob.modifiers:
289                if mod.type == "ARMATURE":
290                    arm_ob = mod.object
291
292        progress = 0
293        progress_count = 1
294        progress_count += 2 if arm_ob else 0
295        progress_count += len(me.shape_keys.key_blocks) * 3 if is_shaped else 0
296
297        if is_shaped:
298            pre_active_shape_key_index = ob.active_shape_key_index
299            pre_relative_keys          = [None] * len(me.shape_keys.key_blocks)
300            pre_shape_key_values       = [0]    * len(me.shape_keys.key_blocks)
301            shape_names                = [""]   * len(me.shape_keys.key_blocks)
302            shape_deforms              = [None] * len(me.shape_keys.key_blocks)
303            for shape_index, shape in enumerate(me.shape_keys.key_blocks):
304                pre_relative_keys   [shape_index] = shape.relative_key.name
305                pre_shape_key_values[shape_index] = shape.value
306                shape_names         [shape_index] = shape.name
307                shape_deforms       [shape_index] = [shape.data[v.index].co.copy() for v in me.vertices]
308                
309                progress += 1
310                context.window_manager.progress_update(progress_start + progress / progress_count)
311
312            ob.active_shape_key_index = len(me.shape_keys.key_blocks) - 1
313            for i in me.shape_keys.key_blocks[:]:
314                ob.shape_key_remove(ob.active_shape_key)
315            
316            new_shape_deforms = []
317            for shape_index, deforms in enumerate(shape_deforms):
318                temp_ob = ob.copy()
319                temp_me = me.copy()
320                temp_ob.data = temp_me
321                compat.link(context.scene, temp_ob)
322                try:
323                    for vert in temp_me.vertices:
324                        vert.co = deforms[vert.index].copy()
325
326                    override = context.copy()
327                    override['object'] = temp_ob
328                    for index, mod in enumerate(temp_ob.modifiers):
329                        if self.is_applies[index].value:
330                            try:
331                                bpy.ops.object.modifier_apply(override, modifier=mod.name)
332                            except:
333                                temp_ob.modifiers.remove(mod)
334
335                    new_shape_deforms.append([v.co.copy() for v in temp_me.vertices])
336                except Exception as e:
337                    #ob.modifiers.remove(mod)
338                    self.report(type={'WARNING'}, message=f_tip_("Could not apply '{}' modifier \"{}\" to shapekey {}", mod.type, mod.name, shape_index))
339                    print(f_("Error applying '{type}' modifier \"{name}\":\n\t", type=mod.type, name=mod.name), e)
340                finally:
341                    common.remove_data(temp_ob)
342                    common.remove_data(temp_me)
343
344                    progress += 1
345                    context.window_manager.progress_update(progress_start + progress / progress_count)
346
347        if ob.active_shape_key_index != 0:
348            ob.active_shape_key_index = 0
349            me.update()
350
351        copy_modifiers = ob.modifiers[:]
352        mod_count = len(copy_modifiers)
353        mod_progress = 0
354        override = context.copy()
355        override['object'] = ob
356        for index, mod in enumerate(copy_modifiers):
357            #if index >= 32: # luvoid : can only apply 32 modifiers at once.
358            #    break
359            if self.is_applies[index].value and (mod.type != 'ARMATURE' or not compat.IS_LEGACY):
360                if mod.type == 'MIRROR' and mod.use_mirror_vertex_groups:
361                    if bpy.ops.object.decode_cm3d2_vertex_group_names.poll():
362                        self.report(type={'WARNING'}, message="Vertex groups are not in blender naming style. Mirror modifier results may not be as expected")
363                    for vg in ob.vertex_groups[:]:
364                        replace_list = ((r'\.L$', ".R"), (r'\.R$', ".L"), (r'\.l$', ".r"), (r'\.r$', ".l"), (r'_L$', "_R"), (r'_R$', "_L"), (r'_l$', "_r"), (r'_r$', "_l"))
365                        for before, after in replace_list:
366                            mirrored_name = re.sub(before, after, vg.name)
367                            if mirrored_name not in ob.vertex_groups:
368                                ob.vertex_groups.new(override, name=mirrored_name)
369                try:
370                    bpy.ops.object.modifier_apply(override, modifier=mod.name)
371                except Exception as e:
372                    #ob.modifiers.remove(mod)
373                    self.report(type={'ERROR', 'WARNING'}, message=f_tip_("Could not apply '{type}' modifier \"{name}\"", type=mod.type, name=mod.name))
374                    print(f_("Error applying '{type}' modifier \"{name}\":\n\t", type=mod.type, name=mod.name), e)
375            
376            mod_progress += 1 if (mod.type != 'ARMATURE' or not compat.IS_LEGACY) else 0
377            context.window_manager.progress_update( progress_start + (progress + mod_progress / mod_count) / progress_count )
378
379        # Calculate custom normals for armature modifiers in legacy blender
380        if arm_ob:
381            bpy.ops.object.mode_set(mode='EDIT')
382            bpy.ops.object.mode_set(mode='OBJECT')
383
384            arm = arm_ob.data
385            arm_pose = arm_ob.pose
386
387            pose_quats = {}
388            for bone in arm.bones:
389                pose_bone = arm_pose.bones[bone.name]
390
391                bone_quat = bone.matrix_local.to_quaternion()
392                pose_quat = pose_bone.matrix.to_quaternion()
393                result_quat = compat.mul(pose_quat, bone_quat.inverted())
394
395                pose_quats[bone.name] = result_quat.copy()
396
397            custom_normals = []
398            for loop in me.loops:
399                vert = me.vertices[loop.vertex_index]
400                no = vert.normal.copy()
401
402                total_weight = 0.0
403                for vge in vert.groups:
404                    vg = ob.vertex_groups[vge.group]
405                    try:
406                        pose_quats[vg.name]
407                    except KeyError:
408                        continue
409                    total_weight += vge.weight
410
411                total_quat = mathutils.Quaternion()
412                if total_weight != 0.0:
413                    for vge in vert.groups:
414                        vg = ob.vertex_groups[vge.group]
415                        try:
416                            total_quat = total_quat.slerp(pose_quats[vg.name], vge.weight / total_weight)
417                        except KeyError:
418                            pass
419                
420                no.rotate(total_quat)
421                custom_normals.append(no)
422
423            progress += 1
424            context.window_manager.progress_update(progress_start + progress / progress_count)
425
426        override = context.copy()
427        override['object'] = ob
428        for index, mod in enumerate(copy_modifiers):
429            #if index >= 32: # luvoid : can only apply 32 modifiers at once.
430            #    break
431            if self.is_applies[index].value and (mod.type == 'ARMATURE' and compat.IS_LEGACY):
432                try:
433                    bpy.ops.object.modifier_apply(override, modifier=mod.name)
434                except Exception as e:
435                    #ob.modifiers.remove(mod)
436                    self.report(type={'ERROR', 'WARNING'}, message=f_tip_("Could not apply '{mod_type}' modifier \"{mod_name}\"", mod_type=mod.type, mod_name=mod.name) )
437                    print(f_("Could not apply '{mod_type}' modifier \"{mod_name}\":\n\t", mod_type=mod.type, mod_name=mod.name), e)
438            
439            mod_progress += 1 if (mod.type == 'ARMATURE' and compat.IS_LEGACY) else 0
440            context.window_manager.progress_update( progress_start + (progress + mod_progress / mod_count) / progress_count )
441
442        progress += 1
443        context.window_manager.progress_update(progress_start + progress / progress_count)
444
445        compat.set_active(context, ob)
446
447        if is_shaped:
448            for deforms in new_shape_deforms:
449                if len(me.vertices) != len(deforms):
450                    self.report(type={'ERROR'}, message="ミラー等が原因で頂点数が変わっているためシェイプキーを格納できません、中止するのでCtrl+Z等で元に戻し修正してください。")
451                    context.window_manager.progress_update(progress_start + 1)
452                    if did_start_progress:
453                        context.window_manager.progress_end()
454                    return {'FINISHED', 'CANCELLED'}
455
456            for shape_index, deforms in enumerate(new_shape_deforms):
457                bpy.ops.object.shape_key_add(context.copy(), from_mix=False)
458                shape = ob.active_shape_key
459                shape.name = shape_names[shape_index]
460
461                for vert in me.vertices:
462                    shape.data[vert.index].co = deforms[vert.index].copy()
463
464                progress += 1
465                context.window_manager.progress_update(progress_start + progress / progress_count)
466
467            for shape_index, shape in enumerate(me.shape_keys.key_blocks):
468                shape.relative_key = me.shape_keys.key_blocks[pre_relative_keys[shape_index]]
469                if self.is_preserve_shape_key_values:
470                    shape.value = pre_shape_key_values[shape_index]
471
472            ob.active_shape_key_index = pre_active_shape_key_index
473
474        for temp_ob in pre_selected_objects:
475            compat.set_select(temp_ob, True)
476        bpy.ops.object.mode_set(mode=pre_mode)
477
478        if arm_ob:
479            for i, loop in enumerate(me.loops):
480                vert = me.vertices[loop.vertex_index]
481                no = vert.normal.copy()
482
483                try:
484                    custom_rot = mathutils.Vector((0.0, 0.0, 1.0)).rotation_difference(custom_normals[i])
485                except:
486                    continue
487                original_rot = mathutils.Vector((0.0, 0.0, 1.0)).rotation_difference(no)
488                output_rot = original_rot.slerp(custom_rot, custom_normal_blend)
489
490                output_no = mathutils.Vector((0.0, 0.0, 1.0))
491                output_no.rotate(output_rot)
492
493                custom_normals[i] = output_no
494            me.use_auto_smooth = True
495            me.normals_split_custom_set(custom_normals)
496
497            progress += 1
498            context.window_manager.progress_update(progress_start + progress / progress_count)
499
500        context.window_manager.progress_update(progress_start + 1)
501        if did_start_progress:
502            context.window_manager.progress_end()
503        return {'FINISHED'}